/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package controle.gui.frames.internos;

import controle.gui.frames.ControleFramePrincipal;
import controle.gui.utils.ApagaElementosDaInterface;
import controle.gui.utils.EnabledGUIElements;
import controle.gui.utils.TamanhoJTextField;
import controle.gui.utils.setEnabledGUIElements;
import controle.interfaces.Constantes;
import controle.utils.Datas;
import controle.utils.Horas;
import gui.frames.internos.IFUsuariosAgentes;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableColumn;
import javax.swing.table.TableModel;
import modelo.Acessos;
import modelo.Agente;
import modelo.Permissao;
import persistencia.dao.AbstractDAO;
import persistencia.dao.TransacaoDAO;

/**
 *
 * @author Maycon Fernando Silva Brito @email mayconfsbrito@gmail.com
 */
public class ControleUsuariosAgentes {

    /*
     * Variáveis da classe
     */
    IFUsuariosAgentes frame = null;
    private final int[] tamanhosJTextField = {45, 45, 45};
    TableModel modeloAcessos;
    private final Integer CODIGO_USUARIO_INATIVO = -1;
    private Integer codigoAnterior = null;

    /*
     * Contrutor da classe
     */
    public ControleUsuariosAgentes(IFUsuariosAgentes frame) {
        this.frame = frame;
    }

    /**
     * Inicializa as configurações padrões da Gui
     */
    public void inicializa() {
        //Limita a quantidade de caracteres possíveis em textMotorista*
        TamanhoJTextField.limitaTamanho(tamanhosJTextField, frame.textNome, frame.textLogin);

        //Inicializa eventos da tabela de Usuários*
        frame.tabelaUsuarios.getSelectionModel().addListSelectionListener(frame.listener);
        frame.tabelaUsuarios.getColumnModel().getSelectionModel().addListSelectionListener(frame.listener);

        this.guiAtiva(true);
        this.limparGUI();
    }

    /**
     * Preenche a interface a partir da seleção de um elemento na tabela
     */
    public void tabelaPreencheGUI() {
        try {

            int linha = frame.tabelaUsuarios.getSelectedRow();

            Integer cod;
            try {
                cod = (Integer) frame.tabelaUsuarios.getValueAt(linha, 0);
            } catch (IndexOutOfBoundsException er) {
                cod = 0;
                return;
            }
            List<Agente> consulta = AbstractDAO.consultar("Agente", "idAgente=" + cod);

            if (consulta.size() > 0) {
                Agente user = consulta.get(0);

                this.preencheGUI(user);
            }
        } catch (ArrayIndexOutOfBoundsException ex) {
            ex.printStackTrace();
        }
    }

    /**
     * Preenche a interface
     *
     * @return
     */
    public boolean preencheGUI(Agente user) {

        this.codigoAnterior = null;
        frame.textCodigo.setEnabled(true);

        //Verifica se o usuário selecionado não é o adminstrador
        if (user.getIdAgente() != 1 || ControleFramePrincipal.user.getIdAgente() == 1) {
            //Preenche os componentes do painel de informações
            frame.textId.setText(user.getIdAgente().toString());
            frame.textCodigo.setText(user.getCodigo().toString());
            frame.textNome.setText(user.getNome());
            frame.textLogin.setText(user.getLogin());
            frame.textDataNascimento.setText(Datas.getText(user.getDataNascimento(), "dd/MM/yyyy"));
            frame.textTelefone.setText(user.getTelefone());
            frame.textDataCadastro.setText(Datas.getText(user.getDataCadastro(), "dd/MM/yyyy"));
            frame.textHora.setText(user.getHoraCadastro().toString());
            frame.textAmostraAtual.setText(user.getNumeroAmostra().toString());
            frame.textAnoAmostra.setText(user.getAnoAmostra().toString());
            this.codigoAnterior = Integer.parseInt(frame.textCodigo.getText().trim());

            if (user.isAtivo()) {
                frame.radioAtivo.setSelected(true);
                frame.textCodigo.setEnabled(true);
            } else {
                frame.radioInativo.setSelected(true);
                frame.textCodigo.setEnabled(false);
            }

            //Preenche a tabela de acessos
            this.listarPesquisaNaTabelaAcessos(user);
            this.guiAtiva(false);
            this.verificaAcessos();

        } else if (user.getIdAgente() == 1 && ControleFramePrincipal.user.getIdAgente() != 1) {
            JOptionPane.showMessageDialog(frame, "O usuário administrador só pode ser consultado ou alterado por ele mesmo!", "Atenção!", JOptionPane.WARNING_MESSAGE);
        }

        return true;
    }

    /**
     * Apaga os elementos da gui
     */
    public void limparGUI() {

        frame.tabelaUsuarios.clearSelection();
        frame.tabelaAcessos.clearSelection();
        this.listarTodosElementosNaTabelaUsuarios();
        this.listarPesquisaNaTabelaAcessos(null);
        new ApagaElementosDaInterface().apagaJTextField(frame.textLogin, frame.textNome, frame.textDataCadastro,
                frame.textHora, frame.textDataNascimento, frame.textTelefone, frame.textCodigo, frame.textId);
        frame.radioAtivo.setSelected(true);

        //Define o próximo código disponível para novos agentes
        frame.textCodigo.setText(this.getCodigoAgenteBd(null, null).toString());
        frame.textCodigo.setEnabled(true);
        frame.textAmostraAtual.setText("0");
        frame.textAnoAmostra.setText(Datas.getYear().toString());

        //Configura o comportamento da gui de acordo com as permissões do usuário
        this.guiAtiva(true);
        this.verificaAcessos();

    }

    /**
     * Configura o comportamento dos elementos da interface
     *
     * @param estado
     */
    public void guiAtiva(boolean estado) {
        if (estado) {
            setEnabledGUIElements.enabledJComponent(frame.buttonCadastro);
            setEnabledGUIElements.disabledJComponent(frame.buttonAlterar);

        } else {
            setEnabledGUIElements.enabledJComponent(frame.buttonAlterar);
            setEnabledGUIElements.disabledJComponent(frame.buttonCadastro);
        }
    }

    /**
     * Verifica o acesso do usuário para utilizar o frame
     */
    protected void verificaAcessos() {

        //Verifica a permissao de @user para este frame
        if (!ControleFramePrincipal.acessos.get(Constantes.PERMISSAO_CADASTRA_ALTERA_USUARIOS).isAcesso()) {
            EnabledGUIElements.disabledJComponent(frame.buttonCadastro, frame.buttonAlterar, frame.buttonRedefinirSenha);
        }
    }

    /**
     * Lista todos os usuários em sua respectiva tabela
     */
    private void listarTodosElementosNaTabelaUsuarios() {

        List<Agente> listUsuarios = AbstractDAO.listar("Agente");

        //Inicializa as colunas da tabela
        TableColumn coluna = frame.tabelaUsuarios.getColumnModel().getColumn(0);
        TableColumn coluna1 = frame.tabelaUsuarios.getColumnModel().getColumn(1);
        TableColumn coluna2 = frame.tabelaUsuarios.getColumnModel().getColumn(2);
        TableColumn coluna3 = frame.tabelaUsuarios.getColumnModel().getColumn(3);

        //Dimensiona as colunas na tabela
        coluna.setPreferredWidth(20);
        coluna1.setPreferredWidth(30);
        coluna2.setPreferredWidth(80);
        coluna3.setPreferredWidth(60);

        //Inicializa o modelo declarado acima
        DefaultTableModel modelo = (DefaultTableModel) frame.tabelaUsuarios.getModel();
        modelo.setNumRows(0);

        try {
            //Preenche a tabela com os elementos de @list
            for (int i = 0; i < listUsuarios.size(); i++) {
                modelo.addRow(new Object[]{listUsuarios.get(i).getIdAgente(), listUsuarios.get(i).getCodigo(),
                            listUsuarios.get(i).getNome(), listUsuarios.get(i).getLogin()});
            }
        } catch (Exception er) {
            JOptionPane.showMessageDialog(null, "Erro na listagem!\n" + er, "Erro!", JOptionPane.ERROR_MESSAGE);
            er.printStackTrace();

        }

        /*
         * Permite o evento de ordernar a tabela a partir do click do mouse
         */
        frame.tabelaUsuarios.setAutoCreateRowSorter(true);
    }

    /**
     * Lista na tabela as permissões do usuário em @list
     *
     * @param list - Lista de permissoes
     */
    public void listarPesquisaNaTabelaAcessos(Agente user) {

        /*
         * Consulta as permissões possíveis
         */
        List<Permissao> listPermissao = AbstractDAO.listar("Permissao");

        /*
         * Inicializa as colunas da tabela
         */
        TableColumn coluna = frame.tabelaAcessos.getColumnModel().getColumn(0);
        TableColumn coluna1 = frame.tabelaAcessos.getColumnModel().getColumn(1);
        TableColumn coluna2 = frame.tabelaAcessos.getColumnModel().getColumn(2);

        /*
         * Dimensiona as colunas na tabela
         */
        coluna.setPreferredWidth(20);
        coluna1.setPreferredWidth(70);
        coluna2.setPreferredWidth(10);

        /*
         * Seta o DefaultTableModel
         */
        DefaultTableModel modelo = (DefaultTableModel) frame.tabelaAcessos.getModel();
        modelo.setNumRows(0);

        /*
         * Caso seja passado em @user o usuário
         */
        if (user != null) {

            /*
             * Consulta os acessos do usuário
             */
            try {
                List<Acessos> listAcessos = AbstractDAO.consultar("Acessos", "idAgente=" + user.getIdAgente());
                /**
                 * Preenche a tabela com os acessos de @user*
                 */
                for (int i = 0; i < listAcessos.size(); i++) {
                    modelo.addRow(new Object[]{listPermissao.get(i).getIdPermissao(), listPermissao.get(i).getNome(), listAcessos.get(i).isAcesso()});
                }

            } catch (Exception er) {
                JOptionPane.showMessageDialog(frame, "Erro na listagem da tabela de acessos do usuário!\n" + er, "Erro!", JOptionPane.ERROR_MESSAGE);
                er.printStackTrace();
            }

        } else {
            /*
             * Preenche a tabela com os tipos de acessos possíveis
             */
            try {
                for (int i = 0; i < listPermissao.size(); i++) {
                    modelo.addRow(new Object[]{listPermissao.get(i).getIdPermissao(), listPermissao.get(i).getNome(), false});
                }
            } catch (Exception er) {
                JOptionPane.showMessageDialog(frame, "Erro na listagem da tabela de acessos do usuário!\n" + er, "Erro!", JOptionPane.ERROR_MESSAGE);
                er.printStackTrace();
            }
        }

    }

    /**
     * Captura os valores da GUI para criar um objeto Usuario
     *
     * @return - Instancia do Usuário capturado pela GUI ou NULL caso a GUI esteja incompleta
     */
    private Agente criaUsuario() {

        //Verifica se os campos obrigatórios estão preenchidos
        if (frame.textNome.getText().isEmpty() || frame.textLogin.getText().isEmpty() || (frame.radioAtivo.isSelected() && frame.radioInativo.isSelected())
                || frame.textAnoAmostra.getText().isEmpty() || frame.textAmostraAtual.getText().isEmpty()) {
            JOptionPane.showMessageDialog(frame, "Pelo menos os seguintes campos precisam ser preenchidos:"
                    + "\nNome."
                    + "\nLogin."
                    + "\nEstado."
                    + "\nAtivo ou inativo."
                    + "\nNumero e Ano da amostra atual.", "Erro!", JOptionPane.WARNING_MESSAGE);

            return null;

        } else {

            //Caso os campos obrigatórios estejam preenchidos, instancia o @user com eles
            Agente user = new Agente();

            //Captura o codigo caso ele esteja preenchido e instancia a senha, para um novo usuario ou para um já existente
            if (!frame.textId.getText().isEmpty()) {

                //Como é um usuário já existente, recupera o código
                user.setIdAgente(Integer.parseInt(frame.textId.getText()));

                //Recupera a senha no bd e instancia @user com ela
                List<Agente> listUser = AbstractDAO.consultar("Agente", "idAgente=" + user.getIdAgente());
                user.setSenha(listUser.get(0).getSenha());

            } else {
                //Caso o código não esteja preenchido, então é um novo usuário
                //Instancia o Id do usuario com a quantidade de usuarios no bd
                List<Agente> listUsuario = AbstractDAO.listar("Agente");
                user.setIdAgente(listUsuario.size() + 1);

                //Instancia com a senha padrao
                user.setSenhaComMD5("123");
            }

            //Captura as informações dos campos de texto
            user.setNome(frame.textNome.getText());
            user.setLogin(frame.textLogin.getText());
            user.setAtivo(frame.radioAtivo.isSelected());
            user.setTelefone(frame.textTelefone.getText());
            user.setDataNascimento(Datas.getDate(frame.textDataNascimento.getText()));
            user.setNumeroAmostra(Integer.parseInt(frame.textAmostraAtual.getText()));
            user.setAnoAmostra(Integer.parseInt(frame.textAnoAmostra.getText()));
            user.setDataCadastro(Datas.getDataHoje());
            user.setHoraCadastro(Horas.getHoraAgora());


            //Verifica se o campo código está vazio
            if (frame.textCodigo.getText().isEmpty()) {
                //Verifica um código disponível no bd
                user.setCodigo(this.getCodigoAgenteBd(user, null));

            } else {
                //Se o campo não estiver vazio
                //Verifica se o código inserido já é do usuário atual ou se está disponível
                user.setCodigo(this.getCodigoAgenteBd(user, Integer.parseInt(frame.textCodigo.getText().trim())));
            }

            if (user.getCodigo() == null) {
                return null;
            }
            
            //Se o usuário estiver ativo, mas o código dele for VALOR_PADRAO, retorna null e envia mensagem
            if (user.isAtivo() && user.getCodigo() == -1) {
                JOptionPane.showMessageDialog(frame, "Este código só é permitido para usuários inativos no sistema.",
                        "Código inválido!", JOptionPane.WARNING_MESSAGE);
                return null;
            
                //Verifica se o código digitado não é menor que -1
            }else if(user.getCodigo() < -1) {
                JOptionPane.showMessageDialog(frame, "Este código é inválido.",
                        "Código inválido!", JOptionPane.WARNING_MESSAGE);
                return null;

                //Se o usuário estiver inativo, mas o código dele for diferente do VALOR_PADRAO
            } else if (!user.isAtivo() && user.getCodigo() != -1) {
                JOptionPane.showMessageDialog(frame, "Este código não é permitido para usuários inativos.",
                        "Código inválido!", JOptionPane.WARNING_MESSAGE);
                return null;
            }

            //Verifica o código do usuário
            if (user.getCodigo() == null) {
                return null;
            } else {
                return user;
            }
        }
    }

    /**
     * Verifica se o usuário atual está cadastrado no bd e se ele já tem um código ou verifica no bd qual o menor código disponível
     *
     * @return
     */
    private Integer getCodigoAgenteBd(Agente user, Integer codigoInserido) {

        //Verifica se o usuário está cadastrado e inativo no bd
        if (user != null && !user.isAtivo()) {
            return this.CODIGO_USUARIO_INATIVO;
        }
        //Verifica se o usuário está cadastrado no bd e se nenhum codigo foi inserido
        if (user != null && user.getIdAgente() != null && codigoInserido == null) {
            //Captura o código dele no bd e retorna
            return ((Agente) AbstractDAO.consultar("Agente", "idAgente=" + user.getIdAgente())).getCodigo();

            //Verifica se o usuário está cadastrado e se algum código em específico será atribuído a ele
        } else if (user != null && user.getIdAgente() != null && codigoInserido != null) {
            //Verifica se o código inserido está disponível ou se já pertence a este usuário
            if (AbstractDAO.consultar("Agente", "codigo=" + codigoInserido).isEmpty()
                    || AbstractDAO.consultar("Agente", "idAgente=" + user.getIdAgente() + " AND codigo=" + codigoInserido).size() > 0) {
                //Retorna o código inserido
                return codigoInserido;

                //Caso o código inserido não esteja diponível
            } else {
                //Avisa e retorna null
                JOptionPane.showMessageDialog(frame, "O código inserido já está sendo utilizado por outro agente.",
                        "Código indisponível!", JOptionPane.WARNING_MESSAGE);
                return null;
            }

            //Caso o usuário não esteja cadastrado mas tenha sido inserido um código
        } else if (user != null && user.getIdAgente() == null && codigoInserido > 0) {

            //Verifica se o código está disponível
            if (AbstractDAO.consultar("Agente", "codigo=" + codigoInserido).isEmpty()) {
                return codigoInserido;

                //Caso o código esteja indisponível
            } else {
                //Avisa e retorna null
                JOptionPane.showMessageDialog(frame, "O código inserido já está sendo utilizado por outro agente.",
                        "Código indisponível!", JOptionPane.WARNING_MESSAGE);
                return null;
            }

            //Caso o usuário não esteja cadastrado e nenhum código tenha sido inserido
        } else {
            //Verifica o menor código disponível no bd
            for (int index = 1; index <= 1000; index++) {
                //Verifica se o código atual não tem nenhum agente cadastrado
                if (AbstractDAO.consultar("Agente", "codigo=" + index).isEmpty()) {
                    //Retorna o código atual
                    return index;
                }
            }
        }
        //Caso não tenha encontrado nenhum código disponível
        return this.CODIGO_USUARIO_INATIVO;
    }

    /**
     * Captura os acessos do usuário
     *
     * @param user
     */
    private ArrayList<Acessos> criaAcessos(Agente user) {

        modeloAcessos = frame.tabelaAcessos.getModel();
        ArrayList<Acessos> acessos = new ArrayList<Acessos>();

        /*
         * Verifica se o usuário já tem seus acessos armazenados no bd
         */
        acessos = (ArrayList<Acessos>) AbstractDAO.consultar("Acessos", "idAgente=" + user.getIdAgente());

        /*
         * Verifica as permissões de cada acesso na tabela de acessos e seta o valor encontrado
         */

        /*
         * Para usuário que já tenha acessos no bd
         */
        if (acessos.size() > 0) {
            for (int linha = 0; linha < modeloAcessos.getRowCount(); linha++) {
                Acessos aces = acessos.get(linha);
                aces.setAcesso(modeloAcessos.getValueAt(linha, 2).equals(true));
                acessos.add(aces);
            }
        } else {
            /*
             * Para usuários que ainda não tenham acessos no bd
             */
            for (int linha = 0; linha < modeloAcessos.getRowCount(); linha++) {

                Permissao p = (Permissao) AbstractDAO.consultar("Permissao", "idPermissao=" + (linha + 1)).get(0);
                acessos.add(new Acessos(user, p, modeloAcessos.getValueAt(linha, 2).equals(true)));
            }
        }

        return acessos;
    }

    /**
     * Reseta a senha do usuário para um valor padrão
     */
    public void redefinirSenha() {

        int opcao = JOptionPane.showOptionDialog(frame, "Você realmente deseja redefinir a senha do usuário " + frame.textNome.getText()
                + "para a senha padrão?\n", "Redefinir Senha",
                JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null,
                frame.botoesOpcoes, frame.botoesOpcoes[0]);

        /*
         * Verifica se o usuário realmente deseja redefinir a senha do usuário selecionado na tabela
         */
        if (opcao == JOptionPane.YES_OPTION) {

            /*
             * Captura o atual usuario da GUI
             */
            Agente user = this.criaUsuario();
            /*
             * Redefine sua senha para 123 e salva no bd
             */
            user.setSenhaComMD5("123");

            if (AbstractDAO.alterar(user)) {
                JOptionPane.showMessageDialog(frame, "A senha do usuário " + frame.textNome.getText() + " foi redefinida para o valor padrão.",
                        "Senha redefinida", JOptionPane.INFORMATION_MESSAGE);
            }

            /*
             * Verifica se o usuario na memoria é o mesmo que alterou a senha
             */
            if (ControleFramePrincipal.user.getIdAgente() == Integer.parseInt(frame.textDataNascimento.getText())) {
                /*
                 * Altera a senha do usuario na memoria
                 */
                ControleFramePrincipal.user.setSenhaComMD5("123");
            }
        }
    }

    /**
     * Cadastra um novo Agente e seus respectivos acessos
     */
    public void cadastrar() {

        //Cria um novo usuário a partir dos dados da GUI
        Agente user = this.criaUsuario();

        //Salva o novo usuario no bd
        if (user != null) {
            if (AbstractDAO.cadastrar(user)) {
                //Salva todos os acessos deste usuario no bd
                if (this.cadastrarAcessos(this.criaAcessos(user))) {
                    JOptionPane.showMessageDialog(frame, "Usuário " + user.getNome() + " cadastrado com sucesso!", "Cadastro de usuário", JOptionPane.INFORMATION_MESSAGE);
                    limparGUI();
                    
                    int id = AbstractDAO.max(Agente.class, "idAgente");
                    TransacaoDAO.cadastrar("Cadastrou o agente id=" + user.getIdAgente() +" código=" + id + ".");
                }
            }
        }
    }

    /**
     * Altera um determinado agente e seus respectivos acessos
     */
    public void alterar() {
        
        //Cria um novo usuário a partir dos dados da GUI
        Agente user = this.criaUsuario();

        //Salva o novo usuario no bd
        if (user != null) {
            if (AbstractDAO.alterar(user)) {
                //Salva todos os acessos deste usuario no bd
                if (this.alterarAcessos(this.criaAcessos(user))) {
                    JOptionPane.showMessageDialog(frame, "Usuário " + user.getNome() + " e seus acessos alterados com sucesso!", "Alteração de usuário", JOptionPane.INFORMATION_MESSAGE);
                    this.limparGUI();
                    
                    TransacaoDAO.cadastrar("Alterou o agente id=" + user.getIdAgente() +" código=" + user.getCodigo() + ".");
                }
            }

            //Verifica se o usuário alterado é o mesmo da memória
            if (user.getIdAgente().equals(ControleFramePrincipal.user.getIdAgente())) {
                //Altera as informações do usuário na memória
                ControleFramePrincipal.user = user;

                //Altera as permissões do usuário na memória e reconfigura o comportamento da interface
                if (!ControleFramePrincipal.verificaAcessos()) {
                    JOptionPane.showMessageDialog(frame, "Erro ao trocar a permissões deste usuário na memória.",
                            "Atenção.", JOptionPane.WARNING_MESSAGE);
                }
            }
        }
    }

    /**
     * Insere todos os acessos de um usuario no bd
     *
     * @param acessos
     * @return
     */
    public boolean cadastrarAcessos(ArrayList<Acessos> acessos) {
        int index = 0;

        while (index < acessos.size()) {
            if (AbstractDAO.cadastrar(acessos.get(index))) {
                index++;
            } else {
                JOptionPane.showMessageDialog(frame, "Erro ao cadastrar os acessos para este usuário!", "ERRO!", JOptionPane.ERROR_MESSAGE);
                return false;
            }
        }
        return true;
    }

    /**
     * Altera no bd todos os acessos presentes em @acessos
     *
     * @param acessos
     * @return
     */
    public boolean alterarAcessos(ArrayList<Acessos> acessos) {

        int index = 0;

        while (index < acessos.size()) {
            if (AbstractDAO.alterar(acessos.get(index))) {
                index++;
            } else {
                JOptionPane.showMessageDialog(frame, "Informações do usuário alteradas, porém houve um erro ao alterar os seus acessos ao sistema.", "Alteração de usuário", JOptionPane.ERROR_MESSAGE);
                return false;
            }
        }

        return true;
    }

    /**
     * Cria ou modifica os acessos de um usuário para administrador total, ou seja, todos os acessos permitidos
     *
     * @param user - Usuário a ter seus acessos criados ou modificados como administrador
     * @return
     */
    public static boolean configuraAcessosAdministrador(Agente user) {

        //Recupera todos os acessos do usuário
        List<Acessos> listAcessos = AbstractDAO.consultar("Acessos", "idAgente=" + user.getIdAgente());

        //Verifica se o usuário não tem acessos cadastrados no bd
        if (listAcessos.isEmpty()) {

            //Recupera todos os tipos de permissões possíveis
            List<Permissao> listPermissao = AbstractDAO.listar("Permissao");

            //Verifica se as permissões do sistema já foram todas cadastradas no bd
            if (listPermissao.size() == Constantes.NUMERO_DE_PERMISSOES) {
                int contador = 0;
                for (int index = 0; index < Constantes.NUMERO_DE_PERMISSOES; index++) {
                    //Insere cada permissão para o usuário, permitindo o acesso
                    if (AbstractDAO.cadastrar(new Acessos(user, listPermissao.get(index), true))) {
                        contador++;
                    }
                }

                //Todos os acessos foram criados para o usuário
                if (contador == Constantes.NUMERO_DE_PERMISSOES) {
                    return true;
                } else {
                    //Os acessos não foram todos criados para o usuário
                    JOptionPane.showMessageDialog(null, "Não foi possível cadastrar os acessos de administrador para o usuário " + user.getNome() + " !", "ERRO!", JOptionPane.ERROR_MESSAGE);
                    return false;
                }
            }

        } else {

            //Caso o usuário já tenha acessos cadastrados no bd
            int contador = 0;

            //Altera todos estes acessos para true
            for (int index = 0; index < listAcessos.size(); index++) {
                Acessos acessoTemporario = listAcessos.get(index);
                acessoTemporario.setAcesso(true);
                if (AbstractDAO.alterar(acessoTemporario)) {
                    contador++;
                }
            }

            //Todos os acessos foram modificados para o usuário
            if (contador == Constantes.NUMERO_DE_PERMISSOES) {
                return true;
            } else {
                //Os acessos não foram todos modificados
                JOptionPane.showMessageDialog(null, "Não foi possível alterar todos os acessos de para o usuário " + user.getNome() + " !", "ERRO!", JOptionPane.ERROR_MESSAGE);
                return false;
            }
        }

        return false;
    }

    /**
     * Caso o usuário da gui seja desativado o código do mesmo é alterado para o VALOR_PADRAO, caso ele seja ativado novamente, seu código é recuperado
     *
     * @return
     */
    public boolean desativaUsuario() {

        //Se o usuário foi desativado
        if (frame.radioInativo.isSelected()) {
            //Armazena o valor atual do código e insere o VALOR_PADRAO no campo do código
            this.codigoAnterior = Integer.parseInt(frame.textCodigo.getText().trim());
            frame.textCodigo.setText(this.CODIGO_USUARIO_INATIVO.toString());
            frame.textCodigo.setEnabled(false);

            return true;
        }

        return false;
    }

    public boolean ativaUsuario() {

        //Se o usuário foi ativado
        if (frame.radioAtivo.isSelected()) {
            //Insere o valor armazenado no campo do código
            frame.textCodigo.setText(this.codigoAnterior.toString().trim());
            frame.textCodigo.setEnabled(true);
            this.codigoAnterior = null;

            return true;
        }
        return false;

    }
}
